Internet Info 1994 March

home *** CD-ROM | disk | FTP | other *** search

/ Internet Info 1994 March / Internet Info CD-ROM (Walnut Creek) (March 1994).iso / networking / terms / kermit / b / vmshex.mar < prev next >

Wrap

Text File | 1988-08-16 | 24.0 KB | 564 lines

.TITLE HEXIFY .SBTTL Stuart Hecht and Eric McQueen .LIBRARY /SYS$LIBRARY:STARLET/ .LIBRARY /SYS$LIBRARY:LIB/ .IDENT /1.1.00/ ;++ ;This will take a task file and turn it into hexidecimal strings ;-- .EXTRN LIB$GET_INPUT .EXTRN LIB$PUT_OUTPUT .EXTRN DSC$K_DTYPE_T .EXTRN DSC$K_CLASS_S .EXTRN SS$_NORMAL .EXTRN RMS$_EOF .MCALL $FAB ; RMS calls .MCALL $RAB .MCALL $CLOSE .MCALL $CONNECT .MCALL $CREATE .MCALL $DISCONNECT .MCALL $READ .MCALL $OPEN .MCALL $PUT .MCALL $RAB_STORE .MCALL $FAB_STORE .SBTTL Definitions of symbols DWRLUN =1 ; Disk read LUN DWWLUN =5 ; Disk write LUN KNORMAL =0 ; No error EOF =-1 ; End of file error code LEFTBYTE=^O377*^O400 ; All one in left byte HEXOFFSET=7 ; Offset to get to 'A from '9+1 CR =13. ; Carriage return LF =10. ; Line feed ; Packet types currently created PKDATA =0 ; Data packet code PKRFM =255. ; Record format PKRAT =254. ; Record attributes PKMRS =253. ; Maximum record size PKALQ =252. ; File length(blocks) PKFILNM =251. ; File name PKEOF =250. ; End of file .SBTTL Data .PSECT $PLIT$,LONG M$FILN: .BYTE CR,LF,LF .ASCII 'Input file name: ' L$FILN =.-M$FILN M$OFLN: .BYTE CR,LF,LF .ASCII 'Output file name (or return for the default): ' L$OFLN =.-M$OFLN M$NEXF: .BYTE CR,LF,LF .ASCII 'Press return to finish or type the name of another file' .BYTE CR,LF .ASCII 'to append to the HEX file: ' L$NEXF =.-M$NEXF M$RMS: .BYTE CR,LF,LF .ASCII 'RMS ERROR' L$RMS =.-M$RMS .EVEN .SBTTL RMS Data DEFALT: .ASCIZ 'SYS$DISK:' ; System default. DEFALN =.-DEFALT ; Size of the default device. .EVEN .SBTTL Storage locations .PSECT $OWN$,LONG .ALIGN LONG MSGDSC: .BLKW 1 ; Data block for terminal output .BYTE DSC$K_DTYPE_T .BYTE DSC$K_CLASS_S ADDR: .ADDRESS ADDR LNGADR: .BLKL 1 INP_STR_D: ; Key string desciptor .BLKL 1 INP_BUF: .ADDRESS ADDR INP_STR_LEN: ; Key string length .BLKL 1 BUCOUNT: .BLKL 1 ; Number of character available in the ; buffer (returned from RMS) RDCOUNT: .BLKL 1 ; Number of characters read from buffer WTCOUNT: .BLKL 1 ; Number of characters written CHCOUNT: .BLKL 1 ; Number of characters written to buff. NULCOUNT: .BLKL 1 ; Number of nulls not yet written CHKSUM: .BLKL 1 ; Checksum for the line ADDRESS: .BLKL 1 ; Current address INP.N: .BLKB 28. ; Space for input file name INP.L =.-INP.N ; Length of input file name OUT.N: .BLKB 28. ; Space for output file name OUT.L =.-OUT.N ; Length of input file name RDBUF: .BLKB 512. ; Disk read buffer WTBUF: .BLKB 512. ; Disk write buffer .EVEN .SBTTL RMS Data structures .ALIGN LONG RDFAB:: $FAB DNA=DEFALT,DNS=DEFALN,FNA=INP.N,FNS=INP.L,- LCH=DWRLUN,FAC=<GET,BIO>,SHR=GET .ALIGN LONG RDRAB:: $RAB FAB=RDFAB,RAC=SEQ ; Beginning of RAB block. .ALIGN LONG WTFAB:: $FAB DNA=DEFALT,DNS=DEFALN,FNA=OUT.N,FNS=OUT.L,- LCH=DWWLUN,FAC=PUT,SHR=NIL,ORG=SEQ,RAT=CR,RFM=VAR .ALIGN LONG WTRAB:: $RAB FAB=WTFAB,RAC=SEQ ; Beginning of RAB block. .SBTTL Main line code .PSECT $CODE$,LONG,EXE .ALIGN LONG HEXIFY:: .WORD ^M<> ; For CALLS that is used from operating system NOINP: MOVAB M$FILN,R11 ; Get the input prompt address MOVL #L$FILN,R12 MOVAB INP.N,R10 ; Get address of input and length MOVL #INP.L,R1 ; JSB READ ; Read the input file name TSTL R0 ; See if we got anything BEQL NOINP ; If no input then try again MOVL R0,R5 ; Save length MOVAB M$OFLN,R11 ; Get the address of the prompt MOVL #L$OFLN,R12 MOVAB OUT.N,R10 ; Get address of output file name MOVL #OUT.L,R1 ; and length JSB READ ; Read the output file name MOVL R0,R3 ; Save length TSTL R3 ; See if we got any input BNEQ GOTFIL ; Yes so branch ; Here so use the default output file name MOVL R5,R0 ; Get the input file length back MOVAB INP.N,R2 ; Get input address MOVAB OUT.N,R3 ; Point at buffer CLRL R1 ; Clear the character count 2$: CMPB (R2),#^A/./ ; Check for an extension BEQL 10$ ; If an extension then ignore rest ; of line MOVB (R2)+,(R3)+ ; Move into the output file name INCW R1 ; Increment counter SOBGTR R0,2$ ; Branch until done 10$: MOVB #^A/./,(R3)+ ; Write the extension for output file MOVB #^A/H/,(R3)+ ; MOVB #^A/E/,(R3)+ ; MOVB #^A/X/,(R3)+ ; ADDW3 #4,R1,R3 ; Get final character count ;++ ;Open files ;-- GOTFIL: ;Create output file MOVAL WTFAB,R1 ; Put address of FAB into R1. $FAB_STORE FAB=R1,FNS=R3 ; Tell RMS file name length $CREATE #WTFAB ; Create the file JSB RMSERR ; Check for file error MOVAL WTRAB,R1 ; Put address of RAB into R1. $RAB_STORE RAB=R1,UBF=WTBUF,RBF=WTBUF,USZ=#512.,RSZ=#512. ; Put address of user buffer in RAB. $CONNECT #WTRAB ; Connect to record. JSB RMSERR ; Check for file error ;Open input file AGAINSAM: MOVAL RDFAB,R1 ; Put address of FAB into R1. $FAB_STORE FAB=R1,FNS=R5 ; Tell RMS file name length $OPEN #RDFAB ; Open the file JSB RMSERR ; Check for file error MOVAL RDRAB,R1 ; Put address of RAB into R1. $RAB_STORE RAB=R1,UBF=RDBUF,RBF=RDBUF,USZ=#512.,RSZ=#512. $CONNECT #RDRAB ; Connect to record. JSB RMSERR ; Check for file error ;++ ;Do the actual work ;-- MOVZWL #512.,RDCOUNT ; Initialize buffer pointers MOVZWL #512.,BUCOUNT ; CLRL WTCOUNT ; CLRL ADDRESS ; Initialize the address CLRL NULCOUNT ; Initialize the number of nulls MOVAL RDFAB,R5 ; Get the FAB address ;Get the Record format (FIX, VAR, ...) MOVZBL #PKRFM,R10 ; Set packet type to record format JSB HEADER ; Output the header MOVZBL FAB$B_RFM(R5),R10 JSB CVTH ; Put the record format code into buff INCL CHCOUNT ; Increment counter JSB PUTLIN ; Write the line out ;Get the record type (CR, ...) MOVZBL #PKRAT,R10 ; Set packet type to record type JSB HEADER ; Output the header MOVZBL FAB$B_RAT(R5),R10 JSB CVTH ; Put the record type into buffer INCL CHCOUNT ; Increment counter JSB PUTLIN ; Write the line out ;Get the maximum record size (512. for tasks) MOVZBL #PKMRS,R10 ; Set packet type to max record size JSB HEADER ; Output the header MOVZWL FAB$W_MRS(R5),R10 PUSHL R10 ; Save for low order EXTZV #8.,#8.,R10,R10 ; Get high order byte JSB CVTH ; Put the record size into buffer INCL CHCOUNT ; Increment counter POPL R10 ; Get size back JSB CVTH ; Put the record size into buffer INCL CHCOUNT ; Increment counter JSB PUTLIN ; Write the line out ;Get the file length (in blocks) MOVZWL #PKALQ,R10 ; Set packet type to file length JSB HEADER ; Output the header MOVL FAB$L_ALQ(R5),R10 PUSHL R10 ; Save for low order EXTZV #8.,#8.,R10,R10 ; Get high order byte JSB CVTH ; Put the allocation into buffer INCL CHCOUNT ; Increment counter POPL R10 ; Get allocation back JSB CVTH ; Put the low order into the buffer INCL CHCOUNT ; Increment counter JSB PUTLIN ; Write the line out ;Get the file name MOVZBL #PKFILNM,R10 ; Set packet type to file name JSB HEADER ; Output the header MOVZBL FAB$B_FNS(R5),R4 MOVAB INP.N,R3 ; Get the input file name address 25$: MOVZBL (R3)+,R10 ; Get the next character JSB CVTH ; Buffer the next character of the name INCL CHCOUNT ; Increment counter SOBGTR R4,25$ ; Repeat until all done JSB PUTLIN ; Write the line out ;++ ; Start moving real data ;-- NEXLIN: JSB GET ; Get a character from the buffer CMPL R10,#EOF ; Check for end of file BEQL FINISH ; If at end the finish up TSTL R10 ; Check for null character BNEQ DOLIN ; Not null so just do regular stuff INCL ADDRESS ; Point to next location BRB NEXLIN ; save space and try again DOLIN: PUSHL R10 ; Save the character we have MOVZWL #PKDATA,R10 ; Set packet type to plain old data JSB HEADER ; Put the standard header into buffer POPL R10 ; Get the original character back LINAGA: JSB CVTHEX ; Convert the character to hex codes INCL ADDRESS ; Point to next location INCL CHCOUNT ; Increment the character count CMPL CHCOUNT,#^O36 ; Check to see if we should finish BNEQ LINMOR ; this line JSB PUTLIN ; Put the whole line to disk BRW NEXLIN ; Go do the next line LINMOR: JSB GET ; Get the next character CMPL R10,#EOF ; Is it an end of file? BNEQ LINAGA ; No, then just handle normally ; JSB PUTLIN ; Yes, write the current line DECL ADDRESS ; Reset address to correct value BRW FIN1 ; Finish up .SBTTL Finish up ;++ ;Finish up ;-- FINISH: MOVZBL #PKDATA,R10 ; Set packet type to plain old data JSB HEADER ; Insert the header so the extra ; nulls are seen FIN1: TSTL NULCOUNT ; See if no nulls left BEQL FIN ; If none then branch CLRL R10 ; Get a null DECL NULCOUNT ; Decrement the counter JSB CVTH ; Convert to HEX (w/o null compression) FIN: JSB PUTLIN ; Put the current buffer to disk ; Write out the end of task file line CLRL CHCOUNT ; Clear character count MOVZBL #PKEOF,R10 ; Get end of task file packet type JSB HEADER ; Make the header JSB PUTLIN ; Write the line ; Close the input (task) file MOVAL RDFAB,R1 ; Get the FAB for input file $CLOSE R1 ; Close input file JSB RMSERR ; Check for file error ; See about another file to append MOVAB M$NEXF,R11 ; See if another file should be MOVL #L$NEXF,R12 ; appended to the HEX file MOVAB INP.N,R10 ; MOVL #INP.L,R1 ; Get address of input and length JSB READ ; Read the input file name TSTL R0 ; See if we got anything BEQL LEAVE ; If no input then leave MOVL R0,R5 ; Put the length in R5 for the open JMP AGAINSAM ; Repeat process for this file ; Write out end of hex file line LEAVE: CLRL CHKSUM ; Clear the checksum for this line CLRL CHCOUNT ; Clear character count MOVZBL #^A/</,R10 ; Get the start character JSB BUFFER ; Put it into the buffer MOVZBL #12.,R5 ; Get the number of nulls needed FINREP: MOVZBL #^A/0/,R10 ; Set the character to 'null' JSB BUFFER ; Put it into the buffer SOBGTR R5,FINREP ; Repeat if not done JSB PUTLIN ; Write the buffer to disk ; Close the HEX file MOVAL WTFAB,R1 ; Get FAB for output file $CLOSE R1 ; Close output file JSB RMSERR ; Check for file error END: MOVL #SS$_NORMAL,R0 ; Set up successful completion RET ; Exit program .SBTTL Put a data line ;++ ;Finish a line up by inserting the length and the checksum and doing a PUT ;-- PUTLIN: MOVL CHCOUNT,R10 ; Get the actual character count SUBL2 NULCOUNT,R10 ; Don't include the nulls since we ; won't write them CLRL NULCOUNT ; Clear the null count since the ; address will serve to insert nulls PUSHL WTCOUNT ; Save it on the stack MOVZBL #1,WTCOUNT ; Move a one into the char count to get JSB CVTH ; to the length and then put length in POPL WTCOUNT ; Restore the correct count MNEGL CHKSUM,R10 ; Negate it JSB CVTH ; Put the negative checksum into buffer JSB PUT ; Put the line to disk RSB ; Return to sender .SBTTL Create the header for the data line ;++ ;This routine will put the starting stuff into the buffer ;R10 contains the record type ;-- HEADER: CLRL CHKSUM ; Clear the checksum for this line CLRL CHCOUNT ; Clear character count PUSHL R10 ; Save the record type MOVZBL #^A/</,R10 ; Move a less-than into first char JSB BUFFER ; position of the buffer CLRL R10 ; Move a fake length into the buffer JSB CVTH ; MOVZBL ADDRESS+3,R10 ; Get the highest order byte of the JSB CVTH ; address and put into the buffer MOVZBL ADDRESS+2,R10 ; Get the 2nd highest order byte of the JSB CVTH ; address and put into the buffer MOVZBL ADDRESS+1,R10 ; Get the 2nd lowest order byte of the JSB CVTH ; address and put into the buffer MOVZBL ADDRESS,R10 ; Get the lowest order byte of the JSB CVTH ; address and buffer it POPL R10 ; Get the line record type JSB CVTH ; and buffer the code RSB ; Return to sender .SBTTL Output and input to/from terminal ;++ ; Write data to terminal. ; R10 Address of data to output ; R1 Length of data ;-- WRITE: MOVW R1,MSGDSC ; Store the length in the descript blk MOVL R10,ADDR ; Store the address of the ASCII PUSHAQ MSGDSC ; Push the descriptor block address CALLS #1,G^LIB$PUT_OUTPUT ; Do the output RSB ; Return to sender ;++ ; Read from the terminal ; R10 Address of buffer ; R1 Number of characters to read ; R11 Input prompt address ; R12 Length of prompt ; ;Returned: ; R0 Number of characters read ;-- READ: MOVL R1,INP_STR_D ; Store the buffer length in desc block MOVL R10,INP_BUF ; Store the buffer address in desc blk MOVL R11,ADDR ; Store prompt address in desc block MOVW R12,MSGDSC ; Store length in desctriptor block PUSHAB INP_STR_LEN ; Address for string length PUSHAQ MSGDSC ; Push address of prompt descriptor blk PUSHAB INP_STR_D ; String buffer descriptor CALLS #3,G^LIB$GET_INPUT ; Get input string value MOVL INP_STR_LEN,R0 ; Get actual input length back RSB ; Return to sender .SBTTL RMS error routine ;++ ;Check for RMS error ;-- RMSERR: BLBC R0,60$ ; If error, go check it out MOVL #KNORMAL,R0 ; Set up a successful return code. RSB ; Return to caller ; Here if there is an error 60$: CMPL #RMS$_EOF,R0 ; Check for EOF BNEQ 70$ ; If not then branch MOVL #EOF,R0 ; Tell sender we have end of file RSB ; Return ; Here if there is an RMS error we don't know how to handle 70$: PUSHL R0 ; Save the error code MOVAB M$RMS,R10 ; Get the address and length of the MOVL #L$RMS,R1 ; message to output JSB WRITE ; Output it POPL R0 ; Get the error code back RET ; Exit program .SBTTL Get a character from the file ;++ ;Get a character from the input file. ; ; Returned: ; R10 Contains the character if not at end of file ; Contains #EOF if at end of file ;-- GET: MOVL RDCOUNT,R10 ; Get the offset into the buffer CMPL R10,BUCOUNT ; Check to see if we are past the end BNEQ 10$ ; If not then branch MOVAL RDRAB,R1 ; Get the RAB address $RAB_STORE RAB=R1,UBF=RDBUF,USZ=#512. $READ R1 ; Get the next buffer of data. JSB RMSERR ; Check for file error CMPL R0,#EOF ; Check for end of file error BNEQ 5$ ; If not then branch MOVL R0,R10 ; Move the status to the correct spot RSB ; Return with error code 5$: MOVZWL RAB$W_RSZ+RDRAB,R10 MOVL R10,BUCOUNT ; Save the record size CLRL R10 ; Clear the pointer CLRL RDCOUNT ; . . . 10$: MOVZBL RDBUF(R10),R10 ; Get the next character INCL RDCOUNT ; Increment the offset into the buffer RSB ; Return to sender .SBTTL Buffer a character of the data line ;++ ; Buffer the character in R10 ;-- BUFFER: PUSHL R10 ; Save the character on the stack MOVL WTCOUNT,R10 ; Get the offset into the buffer CMPL #512.,R10 ; Get too big? BGTR BUFOK NOP BUFOK: MOVB (SP),WTBUF(R10) ; Move the character to the buffer TSTL (SP)+ ; Remove the junk INCL WTCOUNT ; Increment the pointer BUFRTS: RSB ; Return to sender .SBTTL Put a record to the file ;++ ;Write the record ;-- PUT: MOVL WTCOUNT,R10 ; Get the count MOVAL WTRAB,R1 ; Get the RAB address $RAB_STORE RAB=R1,RSZ=R10 $PUT R1 ; Output the record JSB RMSERR ; Check for file error CLRL WTCOUNT ; Clear the counter for next record RSB ; Return .SBTTL Convert to Hexadecimal ASCII digits ;++ ; Convert a word to 2 ASCII hexadecimal digits ;-- CVTHEX: TSTL R10 ; See if this is a null BNEQ CVTH ; If not then just branch INCL NULCOUNT ; A null so just increment the count RSB ; for later and leave ; Convert a word to 2 ASCII hexadecimal digits without null compression CVTH: PUSHL R10 ; Save the character on the stack 10$: TSTL NULCOUNT ; Check to see if there are nulls BEQL 20$ ; If not then just branch CLRL R10 ; Put a null in R10 JSB CVT1 ; Put the null in the buffer DECL NULCOUNT ; Decrement null counter BRB 10$ ; Repeat 20$: POPL R10 ; Get the original value back CVT1: ADDL2 R10,CHKSUM ; Add the value to the checksum MOVL R10,R1 ; Save the value EXTZV #4,#4,R10,R10 ; Get high order digit JSB HEX ; in place and convert to Hex JSB BUFFER ; Buffer the Hex character EXTZV #0,#4,R1,R10 ; Get right digit JSB HEX ; Convert to Hex JSB BUFFER ; Buffer the Hex character RSB ; Return to sender HEX: MOVL R10,R2 ; Move the base to R2 CMPL R2,#9. ; Check to see if above '9 BLEQ 1$ ; If not then branch ADDL2 #HEXOFFSET,R10 ; Add offset to alphabet 1$: ADDL2 #48.,R10 ; Make ASCII RSB ; Return to sender .SBTTL End of Hexify .END HEXIFY